home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 November / PCWNOV08.iso / Software / Freeware / Adobe Media Player 1.1 / adobe_media_player.air / AMP.swf / scripts / mx / controls / RadioButton.as < prev    next >
Encoding:
Text File  |  2008-07-17  |  11.1 KB  |  387 lines
  1. package mx.controls
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.KeyboardEvent;
  5.    import flash.events.MouseEvent;
  6.    import flash.ui.Keyboard;
  7.    import mx.core.FlexVersion;
  8.    import mx.core.IFlexDisplayObject;
  9.    import mx.core.mx_internal;
  10.    import mx.events.FlexEvent;
  11.    import mx.events.ItemClickEvent;
  12.    import mx.managers.IFocusManager;
  13.    import mx.managers.IFocusManagerGroup;
  14.    
  15.    use namespace mx_internal;
  16.    
  17.    public class RadioButton extends Button implements IFocusManagerGroup
  18.    {
  19.       mx_internal static var createAccessibilityImplementation:Function;
  20.       
  21.       mx_internal static const VERSION:String = "3.0.0.0";
  22.       
  23.       private var _group:RadioButtonGroup;
  24.       
  25.       mx_internal var _groupName:String;
  26.       
  27.       private var _value:Object;
  28.       
  29.       private var groupChanged:Boolean = false;
  30.       
  31.       mx_internal var indexNumber:int = 0;
  32.       
  33.       public function RadioButton()
  34.       {
  35.          super();
  36.          mx_internal::_labelPlacement = "";
  37.          mx_internal::_toggle = true;
  38.          groupName = "radioGroup";
  39.          addEventListener(FlexEvent.ADD,addHandler);
  40.          mx_internal::centerContent = false;
  41.          mx_internal::extraSpacing = 8;
  42.       }
  43.       
  44.       private function addHandler(param1:FlexEvent) : void
  45.       {
  46.          if(!_group && initialized)
  47.          {
  48.             addToGroup();
  49.          }
  50.       }
  51.       
  52.       private function setNext(param1:Boolean = true) : void
  53.       {
  54.          var _loc5_:RadioButton = null;
  55.          var _loc2_:RadioButtonGroup = group;
  56.          var _loc3_:IFocusManager = focusManager;
  57.          if(_loc3_)
  58.          {
  59.             _loc3_.showFocusIndicator = true;
  60.          }
  61.          var _loc4_:int = mx_internal::indexNumber + 1;
  62.          while(_loc4_ < _loc2_.numRadioButtons)
  63.          {
  64.             _loc5_ = _loc2_.getRadioButtonAt(_loc4_);
  65.             if((Boolean(_loc5_)) && _loc5_.enabled)
  66.             {
  67.                if(param1)
  68.                {
  69.                   _loc2_.mx_internal::setSelection(_loc5_);
  70.                }
  71.                _loc5_.setFocus();
  72.                return;
  73.             }
  74.             _loc4_++;
  75.          }
  76.          if(param1 && _loc2_.getRadioButtonAt(mx_internal::indexNumber) != _loc2_.selection)
  77.          {
  78.             _loc2_.mx_internal::setSelection(this);
  79.          }
  80.          this.drawFocus(true);
  81.       }
  82.       
  83.       private function addToGroup() : Object
  84.       {
  85.          var _loc1_:RadioButtonGroup = group;
  86.          if(_loc1_)
  87.          {
  88.             _loc1_.mx_internal::addInstance(this);
  89.          }
  90.          return _loc1_;
  91.       }
  92.       
  93.       override protected function commitProperties() : void
  94.       {
  95.          super.commitProperties();
  96.          if(groupChanged)
  97.          {
  98.             addToGroup();
  99.             groupChanged = false;
  100.          }
  101.       }
  102.       
  103.       override protected function clickHandler(param1:MouseEvent) : void
  104.       {
  105.          if(!enabled || selected)
  106.          {
  107.             return;
  108.          }
  109.          if(!_group)
  110.          {
  111.             addToGroup();
  112.          }
  113.          super.clickHandler(param1);
  114.          group.mx_internal::setSelection(this);
  115.          var _loc2_:ItemClickEvent = new ItemClickEvent(ItemClickEvent.ITEM_CLICK);
  116.          _loc2_.label = label;
  117.          _loc2_.index = mx_internal::indexNumber;
  118.          _loc2_.relatedObject = this;
  119.          _loc2_.item = value;
  120.          group.dispatchEvent(_loc2_);
  121.       }
  122.       
  123.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  124.       {
  125.          super.keyUpHandler(param1);
  126.          if(param1.keyCode == Keyboard.SPACE && !mx_internal::_toggle)
  127.          {
  128.             mx_internal::_toggle = true;
  129.          }
  130.       }
  131.       
  132.       [Bindable("labelPlacementChanged")]
  133.       override public function get labelPlacement() : String
  134.       {
  135.          var _loc1_:String = ButtonLabelPlacement.RIGHT;
  136.          if(mx_internal::_labelPlacement != "")
  137.          {
  138.             _loc1_ = mx_internal::_labelPlacement;
  139.          }
  140.          else if(Boolean(_group) && _group.labelPlacement != "")
  141.          {
  142.             _loc1_ = _group.labelPlacement;
  143.          }
  144.          return _loc1_;
  145.       }
  146.       
  147.       public function set groupName(param1:String) : void
  148.       {
  149.          if(!param1 || param1 == "")
  150.          {
  151.             return;
  152.          }
  153.          mx_internal::deleteGroup();
  154.          mx_internal::_groupName = param1;
  155.          groupChanged = true;
  156.          invalidateProperties();
  157.          invalidateDisplayList();
  158.          dispatchEvent(new Event("groupNameChanged"));
  159.       }
  160.       
  161.       override protected function initializeAccessibility() : void
  162.       {
  163.          if(RadioButton.mx_internal::createAccessibilityImplementation != null)
  164.          {
  165.             RadioButton.mx_internal::createAccessibilityImplementation(this);
  166.          }
  167.       }
  168.       
  169.       private function setThis() : void
  170.       {
  171.          if(!_group)
  172.          {
  173.             addToGroup();
  174.          }
  175.          var _loc1_:RadioButtonGroup = group;
  176.          if(_loc1_.selection != this)
  177.          {
  178.             _loc1_.mx_internal::setSelection(this);
  179.          }
  180.       }
  181.       
  182.       override public function get emphasized() : Boolean
  183.       {
  184.          return false;
  185.       }
  186.       
  187.       override public function get toggle() : Boolean
  188.       {
  189.          return super.toggle;
  190.       }
  191.       
  192.       override protected function measure() : void
  193.       {
  194.          var _loc1_:Number = NaN;
  195.          var _loc2_:Number = NaN;
  196.          var _loc3_:Number = NaN;
  197.          var _loc4_:Number = NaN;
  198.          super.measure();
  199.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  200.          {
  201.             _loc1_ = measureText(label).height;
  202.             _loc2_ = !!mx_internal::currentIcon ? Number(mx_internal::currentIcon.height) : 0;
  203.             if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  204.             {
  205.                _loc3_ = Math.max(_loc1_,_loc2_);
  206.             }
  207.             else
  208.             {
  209.                _loc3_ = _loc1_ + _loc2_;
  210.                _loc4_ = getStyle("verticalGap");
  211.                if(_loc2_ != 0 && !isNaN(_loc4_))
  212.                {
  213.                   _loc3_ += _loc4_;
  214.                }
  215.             }
  216.             measuredMinHeight = measuredHeight = Math.max(_loc3_,18);
  217.          }
  218.       }
  219.       
  220.       override public function set toggle(param1:Boolean) : void
  221.       {
  222.       }
  223.       
  224.       mx_internal function deleteGroup() : void
  225.       {
  226.          try
  227.          {
  228.             if(document[groupName])
  229.             {
  230.                delete document[groupName];
  231.             }
  232.          }
  233.          catch(e:Error)
  234.          {
  235.             try
  236.             {
  237.                if(document.automaticRadioButtonGroups[groupName])
  238.                {
  239.                   delete document.automaticRadioButtonGroups[groupName];
  240.                }
  241.             }
  242.             catch(e1:Error)
  243.             {
  244.             }
  245.          }
  246.       }
  247.       
  248.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  249.       {
  250.          switch(param1.keyCode)
  251.          {
  252.             case Keyboard.DOWN:
  253.                setNext(!param1.ctrlKey);
  254.                param1.stopPropagation();
  255.                break;
  256.             case Keyboard.UP:
  257.                setPrev(!param1.ctrlKey);
  258.                param1.stopPropagation();
  259.                break;
  260.             case Keyboard.LEFT:
  261.                setPrev(!param1.ctrlKey);
  262.                param1.stopPropagation();
  263.                break;
  264.             case Keyboard.RIGHT:
  265.                setNext(!param1.ctrlKey);
  266.                param1.stopPropagation();
  267.                break;
  268.             case Keyboard.SPACE:
  269.                setThis();
  270.                mx_internal::_toggle = false;
  271.             default:
  272.                super.keyDownHandler(param1);
  273.          }
  274.       }
  275.       
  276.       [Bindable("groupNameChanged")]
  277.       public function get groupName() : String
  278.       {
  279.          return mx_internal::_groupName;
  280.       }
  281.       
  282.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  283.       {
  284.          super.updateDisplayList(param1,param2);
  285.          if(groupChanged)
  286.          {
  287.             addToGroup();
  288.             groupChanged = false;
  289.          }
  290.          if(_group && mx_internal::_selected && _group.selection != this)
  291.          {
  292.             group.mx_internal::setSelection(this,false);
  293.          }
  294.       }
  295.       
  296.       [Bindable("valueChanged")]
  297.       public function get value() : Object
  298.       {
  299.          return _value;
  300.       }
  301.       
  302.       public function set value(param1:Object) : void
  303.       {
  304.          _value = param1;
  305.          dispatchEvent(new Event("valueChanged"));
  306.       }
  307.       
  308.       private function setPrev(param1:Boolean = true) : void
  309.       {
  310.          var _loc5_:RadioButton = null;
  311.          var _loc2_:RadioButtonGroup = group;
  312.          var _loc3_:IFocusManager = focusManager;
  313.          if(_loc3_)
  314.          {
  315.             _loc3_.showFocusIndicator = true;
  316.          }
  317.          var _loc4_:int = 1;
  318.          while(_loc4_ <= mx_internal::indexNumber)
  319.          {
  320.             _loc5_ = _loc2_.getRadioButtonAt(mx_internal::indexNumber - _loc4_);
  321.             if((Boolean(_loc5_)) && _loc5_.enabled)
  322.             {
  323.                if(param1)
  324.                {
  325.                   _loc2_.mx_internal::setSelection(_loc5_);
  326.                }
  327.                _loc5_.setFocus();
  328.                return;
  329.             }
  330.             _loc4_++;
  331.          }
  332.          if(param1 && _loc2_.getRadioButtonAt(mx_internal::indexNumber) != _loc2_.selection)
  333.          {
  334.             _loc2_.mx_internal::setSelection(this);
  335.          }
  336.          this.drawFocus(true);
  337.       }
  338.       
  339.       public function set group(param1:RadioButtonGroup) : void
  340.       {
  341.          _group = param1;
  342.       }
  343.       
  344.       public function get group() : RadioButtonGroup
  345.       {
  346.          var g:RadioButtonGroup = null;
  347.          if(!document)
  348.          {
  349.             return _group;
  350.          }
  351.          if(!_group)
  352.          {
  353.             if(Boolean(groupName) && groupName != "")
  354.             {
  355.                try
  356.                {
  357.                   g = RadioButtonGroup(document[groupName]);
  358.                }
  359.                catch(e:Error)
  360.                {
  361.                   if(Boolean(document.automaticRadioButtonGroups) && Boolean(document.automaticRadioButtonGroups[groupName]))
  362.                   {
  363.                      g = RadioButtonGroup(document.automaticRadioButtonGroups[groupName]);
  364.                   }
  365.                }
  366.                if(!g)
  367.                {
  368.                   g = new RadioButtonGroup(IFlexDisplayObject(document));
  369.                   if(!document.automaticRadioButtonGroups)
  370.                   {
  371.                      document.automaticRadioButtonGroups = {};
  372.                   }
  373.                   document.automaticRadioButtonGroups[groupName] = g;
  374.                }
  375.                else if(!(g is RadioButtonGroup))
  376.                {
  377.                   return null;
  378.                }
  379.                _group = g;
  380.             }
  381.          }
  382.          return _group;
  383.       }
  384.    }
  385. }
  386.  
  387.